nanopyx.core.generate.beads

  1import numpy as np
  2from math import sqrt
  3from skimage.filters import gaussian
  4from skimage.transform import EuclideanTransform, warp
  5
  6from ..transform.blocks import assemble_frame_from_blocks
  7
  8
  9def generate_random_position(n_rows, n_cols):
 10    """
 11    Generates a random position given number of rows and columns.
 12    :param n_rows: int; number of rows
 13    :param n_cols: int; number of columns
 14    :return: int, int; random position constrained to 0.1 and 0.9 of n_rows and n_cols
 15    """
 16
 17    min_r = int(n_rows * 0.1)
 18    max_r = int(n_rows * 0.9)
 19
 20    min_c = int(n_cols * 0.1)
 21    max_c = int(n_cols * 0.9)
 22
 23    r = np.random.randint(min_r, max_r)
 24    c = np.random.randint(min_c, max_c)
 25
 26    return r, c
 27
 28def generate_image(n_objects=10, shape=(2, 300, 300), dtype=np.float16):
 29    """
 30    Generates a random image with objects in random positions
 31    :param n_objects: int; number of objects to generate
 32    :param shape: tuple; with shape (z, y, x)
 33    :param dtype: data type to be used in the generated numpy array
 34    :return: numpy array with shape (z, y, x) and defined data type and n_objects
 35    """
 36
 37    img = np.zeros(shape).astype(dtype)
 38
 39    n_rows = img.shape[1]
 40    n_cols = img.shape[2]
 41
 42    for i in range(n_objects):
 43        r, c = generate_random_position(n_rows, n_cols)
 44        img[:, r, c] = np.finfo(np.float16).max
 45
 46    for i in range(img.shape[0]):
 47        img[i] = gaussian(img[i], sigma=3)
 48
 49    return img
 50
 51def generate_timelapse_drift(n_objects=10, shape=(10, 300, 300), dtype=np.float16, drift=None,
 52                             drift_mode="directional"):
 53    """
 54    Generate random timelapse image with drift over time.
 55    :param n_objects: int; number of objects to generate
 56    :param shape: tuple; with shape (t, y, x)
 57    :param dtype: data type to be used in the generated numpy array
 58    :param drift: None or int; number of pixels corresponding to drift between frames. If None, automatic drift is
 59    calculated based on 0.02 of image dimensions.
 60    :param drift_mode: str; "directional" (default) or "random";
 61    :return: numpy array with shape (t, y, x) and defined data type and n_objects
 62    """
 63
 64    if drift is None:
 65        drift = min(shape[1]*0.02, shape[2]*0.02)
 66
 67    img = generate_image(n_objects=n_objects, shape=shape, dtype=dtype)
 68
 69    if drift_mode == "directional":
 70        transformation_matrix = EuclideanTransform(translation=(-drift, -drift))
 71        for i in range(shape[0]-1):
 72            img[i+1] = warp(img[i], transformation_matrix.inverse, order=3, preserve_range=True)
 73
 74    elif drift_mode == "random":
 75        for i in range(shape[0]-1):
 76
 77            state = np.random.randint(0, 3)
 78
 79            if state == 1:
 80                transformation_matrix = EuclideanTransform(translation=(-sqrt(drift), -sqrt(drift)))
 81            elif state == 2:
 82                transformation_matrix = EuclideanTransform(translation=(-sqrt(drift), sqrt(drift)))
 83            elif state == 3:
 84                transformation_matrix = EuclideanTransform(translation=(sqrt(drift), -sqrt(drift)))
 85            else:
 86                transformation_matrix = EuclideanTransform(translation=(sqrt(drift), sqrt(drift)))
 87
 88            img[i+1] = warp(img[i], transformation_matrix.inverse, order=3, preserve_range=True)
 89
 90    return img
 91
 92def generate_channel_misalignment():
 93    """
 94    Generates an image with shape (3, 300, 300) with 1 object centered on each 3x3 block of the image.
 95    Slices corresponding to channel 2 and 3 are shifted relative to channel 1 (template).
 96    :return: numpy array of shape (3, 300, 300) corresponding to a random image with misalignment between channels.
 97    """
 98
 99    n_blocks = 3
100    h = 300
101    w = 300
102
103    block_img = np.zeros((int(h/n_blocks), int(w/n_blocks)))
104    block_h = int(h / n_blocks)
105    block_w = int(w / n_blocks)
106    block_img[int(block_h/2), int(block_w/2)] = 1
107    block_img = gaussian(block_img, sigma=3)
108
109    ref_channel = np.zeros((h, w))
110    misaligned_blocks = []
111    misaligned_blocks_2 = []
112
113    for x_i in range(n_blocks):
114        for y_i in range(n_blocks):
115            ref_channel[y_i*block_h:y_i*block_h+block_h, x_i*block_w:x_i*block_w+block_w] += block_img
116
117    misalignments = [(-3, -3), (-3, 0), (-3, 3), (0, -3), (0, 0), (0, 3), (3, -3), (3, 0), (3, 3)]
118
119    for mis in misalignments:
120        block_img = np.zeros((int(h/n_blocks), int(w/n_blocks)))
121        block_h = h / n_blocks
122        block_w = w / n_blocks
123        block_img[int(block_h/2)+mis[0], int(block_w/2)+mis[1]] = 1
124        block_img = gaussian(block_img, sigma=3)
125        misaligned_blocks.append(block_img)
126
127    misalignments.reverse()
128
129    for mis in misalignments:
130        block_img = np.zeros((int(h/n_blocks), int(w/n_blocks)))
131        block_h = h / n_blocks
132        block_w = w / n_blocks
133        block_img[int(block_h/2)+mis[0], int(block_w/2)+mis[1]] = 1
134        block_img = gaussian(block_img, sigma=3)
135        misaligned_blocks_2.append(block_img)
136
137    misaligned_channel = assemble_frame_from_blocks(np.array(misaligned_blocks), 3, 3)
138    misaligned_channel_2 = assemble_frame_from_blocks(np.array(misaligned_blocks_2), 3, 3)
139
140    return np.array([ref_channel, misaligned_channel, misaligned_channel_2]).astype(np.float16)